// API基础配置
export const API_BASE_URL = import.meta.env.VITE_APP_API_BASE_URL + '/api'
console.log('API_BASE_URL:', API_BASE_URL)

// 导入认证工具
import { getToken } from './auth.js'

/**
 * 通用API请求函数
 * @param {string} url - 请求URL
 * @param {object} options - 请求选项
 * @returns {Promise} 请求结果
 */
export async function request(url, options = {}) {
  const token = getToken()

  // 处理请求体
  let body = options.body
  if (body && typeof body === 'object' && !(body instanceof FormData)) {
    body = JSON.stringify(body)
  }

  const config = {
    headers: {
      // 只有在不是 FormData 时才设置 Content-Type
      ...(body instanceof FormData ? {} : { 'Content-Type': 'application/json' }),
      ...(token && { Authorization: `Bearer ${token}` }),
      ...options.headers
    },
    ...options,
    body
  }

  try {
    const response = await fetch(url, config)

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`)
    }

    // 检查响应类型
    const contentType = response.headers.get('content-type')
    let data

    if (contentType && contentType.includes('application/json')) {
      data = await response.json()

      // 检查API返回的code
      if (data.code !== 200) {
        throw new Error(data.msg || '请求失败')
      }
    } else {
      // 对于非JSON响应（如文件下载），直接返回响应
      // 注意：这里不能调用 response.json() 或 response.text()，因为会消耗响应体
      data = response
    }

    return data
  } catch (error) {
    throw error
  }
}

/**
 * 获取echarts列表数据
 * @param {object} params - 查询参数
 * @param {number} params.page - 页码，默认1
 * @param {number} params.limit - 每页数量，默认10
 * @param {string} params.type - 图表类型过滤，可选
 * @returns {Promise} 包含列表数据和分页信息的响应
 */
export async function getEchartsList(params = {}) {
  const { page = 1, limit = 10, type } = params

  // 构建查询参数
  const searchParams = new URLSearchParams({
    page: page.toString(),
    limit: limit.toString()
  })

  // 只有当type不为'all'时才添加type参数
  if (type && type !== 'all') {
    searchParams.append('type', type)
  }

  const url = `${API_BASE_URL}/echarts/list?${searchParams.toString()}`

  return await request(url)
}

/**
 * 获取echarts详情数据
 * @param {string|number} id - 图表ID
 * @returns {Promise} 图表详情数据
 */
export async function getEchartsDetail(id) {
  if (!id) {
    throw new Error('图表ID不能为空')
  }

  const url = `${API_BASE_URL}/echarts/detail/${id}`

  return await request(url)
}

/**
 * 发送邮箱验证码
 * @param {string} email - 邮箱地址
 * @returns {Promise} 发送结果
 */
export async function sendEmailCode(email) {
  if (!email) {
    throw new Error('邮箱地址不能为空')
  }

  const url = `${API_BASE_URL}/auth/send-verification-code`

  return await request(url, {
    method: 'POST',
    body: JSON.stringify({ email })
  })
}

/**
 * 用户注册
 * @param {object} userData - 用户注册数据
 * @param {string} userData.username - 用户名
 * @param {string} userData.email - 邮箱
 * @param {string} userData.password - 密码
 * @param {string} userData.verificationCode - 邮箱验证码
 * @returns {Promise} 注册结果，包含token和用户信息
 */
export async function register(userData) {
  const { username, email, password, verificationCode } = userData

  if (!username || !email || !password || !verificationCode) {
    throw new Error('用户名、邮箱、密码和验证码不能为空')
  }

  const url = `${API_BASE_URL}/auth/register`

  return await request(url, {
    method: 'POST',
    body: JSON.stringify({ username, email, password, verificationCode })
  })
}

/**
 * 用户登录
 * @param {object} loginData - 用户登录数据
 * @param {string} loginData.username - 用户名
 * @param {string} loginData.password - 密码
 * @returns {Promise} 登录结果，包含token和用户信息
 */
export async function login(loginData) {
  const { username, password } = loginData

  if (!username || !password) {
    throw new Error('用户名和密码不能为空')
  }

  const url = `${API_BASE_URL}/auth/login`

  return await request(url, {
    method: 'POST',
    body: JSON.stringify({ username, password })
  })
}

/**
 * 发送忘记密码验证码
 * @param {string} email - 邮箱地址
 * @returns {Promise} 发送结果
 */
export async function forgotPassword(email) {
  if (!email) {
    throw new Error('邮箱地址不能为空')
  }

  const url = `${API_BASE_URL}/auth/forgot-password`

  return await request(url, {
    method: 'POST',
    body: JSON.stringify({ email })
  })
}

/**
 * 重置密码
 * @param {object} resetData - 重置密码数据
 * @param {string} resetData.email - 邮箱地址
 * @param {string} resetData.verificationCode - 验证码
 * @param {string} resetData.newPassword - 新密码
 * @returns {Promise} 重置结果
 */
export async function resetPassword(resetData) {
  const { email, verificationCode, newPassword } = resetData

  if (!email || !verificationCode || !newPassword) {
    throw new Error('邮箱、验证码和新密码不能为空')
  }

  const url = `${API_BASE_URL}/auth/reset-password`

  return await request(url, {
    method: 'POST',
    body: JSON.stringify({ email, verificationCode, newPassword })
  })
}

/**
 * 获取当前用户信息
 * @returns {Promise} 用户信息
 */
export async function getCurrentUser() {
  const url = `${API_BASE_URL}/auth/profile`
  return await request(url)
}

/**
 * 验证token是否有效
 * @returns {Promise} token验证结果，包含有效性和用户信息
 */
export async function verifyToken() {
  const url = `${API_BASE_URL}/auth/verify-token`
  return await request(url)
}

/**
 * 刷新token
 * @returns {Promise} 新的token信息
 */
export async function refreshToken() {
  const url = `${API_BASE_URL}/auth/refresh-token`

  return await request(url, {
    method: 'POST'
  })
}

/**
 * 获取用户完整的书签数据（分类+书签）
 * @returns {Promise} 包含分类和书签的完整数据
 */
export async function getBookmarkData() {
  const url = `${API_BASE_URL}/bookmarks/data`
  return await request(url)
}

// ============== 分类相关接口 ==============

/**
 * 获取用户所有分类
 * @returns {Promise} 分类列表
 */
export async function getCategories() {
  const url = `${API_BASE_URL}/bookmarks/categories`
  return await request(url)
}

/**
 * 创建分类
 * @param {object} categoryData - 分类数据
 * @param {string} categoryData.key - 分类key
 * @param {string} categoryData.label - 分类名称
 * @param {number} categoryData.sortOrder - 排序序号
 * @returns {Promise} 创建结果
 */
export async function createCategory(categoryData) {
  const { key, label, sortOrder = 0 } = categoryData

  if (!key || !label) {
    throw new Error('分类key和名称不能为空')
  }

  const url = `${API_BASE_URL}/bookmarks/categories`

  return await request(url, {
    method: 'POST',
    body: JSON.stringify({ key, label, sortOrder })
  })
}

/**
 * 更新分类
 * @param {string|number} id - 分类ID
 * @param {object} categoryData - 分类数据
 * @param {string} categoryData.key - 分类key
 * @param {string} categoryData.label - 分类名称
 * @param {number} categoryData.sortOrder - 排序序号
 * @returns {Promise} 更新结果
 */
export async function updateCategory(id, categoryData) {
  const { key, label, sortOrder } = categoryData

  if (!id) {
    throw new Error('分类ID不能为空')
  }

  if (!key || !label) {
    throw new Error('分类key和名称不能为空')
  }

  const url = `${API_BASE_URL}/bookmarks/categories/${id}`

  return await request(url, {
    method: 'PUT',
    body: JSON.stringify({ key, label, sortOrder })
  })
}

/**
 * 删除分类
 * @param {string|number} id - 分类ID
 * @returns {Promise} 删除结果
 */
export async function deleteCategory(id) {
  if (!id) {
    throw new Error('分类ID不能为空')
  }

  const url = `${API_BASE_URL}/bookmarks/categories/${id}`

  return await request(url, {
    method: 'DELETE'
  })
}

// ============== 书签相关接口 ==============

/**
 * 获取用户所有书签
 * @param {object} params - 查询参数
 * @param {string} params.categoryId - 分类ID过滤，可选
 * @param {number} params.page - 页码，默认1
 * @param {number} params.limit - 每页数量，默认50
 * @returns {Promise} 书签列表和分页信息
 */
export async function getBookmarks(params = {}) {
  const { categoryId, page = 1, limit = 50 } = params

  // 构建查询参数
  const searchParams = new URLSearchParams({
    page: page.toString(),
    limit: limit.toString()
  })

  if (categoryId) {
    searchParams.append('categoryId', categoryId)
  }

  const url = `${API_BASE_URL}/bookmarks/bookmarks?${searchParams.toString()}`

  return await request(url)
}

/**
 * 创建书签
 * @param {object} bookmarkData - 书签数据
 * @param {string} bookmarkData.title - 书签标题
 * @param {string} bookmarkData.url - 书签URL
 * @param {string} bookmarkData.description - 书签描述，可选
 * @param {string|number} bookmarkData.categoryId - 分类ID
 * @param {number} bookmarkData.sortOrder - 排序序号，可选
 * @returns {Promise} 创建结果
 */
export async function createBookmark(bookmarkData) {
  const { title, url, description, categoryId, sortOrder = 0 } = bookmarkData

  if (!title || !url || !categoryId) {
    throw new Error('标题、URL和分类不能为空')
  }

  const url_api = `${API_BASE_URL}/bookmarks/bookmarks`

  return await request(url_api, {
    method: 'POST',
    body: JSON.stringify({ title, url, description, categoryId, sortOrder })
  })
}

/**
 * 更新书签
 * @param {string|number} id - 书签ID
 * @param {object} bookmarkData - 书签数据
 * @param {string} bookmarkData.title - 书签标题
 * @param {string} bookmarkData.url - 书签URL
 * @param {string} bookmarkData.description - 书签描述，可选
 * @param {string|number} bookmarkData.categoryId - 分类ID
 * @param {number} bookmarkData.sortOrder - 排序序号，可选
 * @returns {Promise} 更新结果
 */
export async function updateBookmark(id, bookmarkData) {
  const { title, url, description, categoryId, sortOrder } = bookmarkData

  if (!id) {
    throw new Error('书签ID不能为空')
  }

  if (!title || !url || !categoryId) {
    throw new Error('标题、URL和分类不能为空')
  }

  const url_api = `${API_BASE_URL}/bookmarks/bookmarks/${id}`

  return await request(url_api, {
    method: 'PUT',
    body: JSON.stringify({ title, url, description, categoryId, sortOrder })
  })
}

/**
 * 删除书签
 * @param {string|number} id - 书签ID
 * @returns {Promise} 删除结果
 */
export async function deleteBookmark(id) {
  if (!id) {
    throw new Error('书签ID不能为空')
  }

  const url = `${API_BASE_URL}/bookmarks/bookmarks/${id}`

  return await request(url, {
    method: 'DELETE'
  })
}

// ============== 综合接口 ==============

/**
 * 批量导入书签数据
 * @param {object} data - 导入数据
 * @param {Array} data.categories - 分类数据
 * @param {Array} data.bookmarks - 书签数据
 * @returns {Promise} 导入结果
 */
export async function importBookmarkData(data) {
  const { categories, bookmarks } = data

  if (!categories || !bookmarks) {
    throw new Error('分类和书签数据不能为空')
  }

  const url = `${API_BASE_URL}/bookmarks/import`

  return await request(url, {
    method: 'POST',
    body: JSON.stringify({ categories, bookmarks })
  })
}

/**
 * 批量更新分类排序
 * @param {Array} categories - 排序后的分类数组
 * @returns {Promise} 更新结果
 */
export async function updateCategoriesSort(categories) {
  const promises = categories
    .map((category, index) => {
      if (category.id) {
        return updateCategory(category.id, {
          key: category.key,
          label: category.label,
          sortOrder: index
        })
      }
    })
    .filter(Boolean)

  return await Promise.all(promises)
}

/**
 * 批量更新书签排序
 * @param {Array} bookmarks - 排序后的书签数组
 * @returns {Promise} 更新结果
 */
export async function updateBookmarksSort(bookmarks) {
  const promises = bookmarks
    .map((bookmark, index) => {
      if (bookmark.id) {
        return updateBookmark(bookmark.id, {
          title: bookmark.title,
          url: bookmark.url,
          description: bookmark.description,
          categoryId: bookmark.categoryId || bookmark.category_id,
          sortOrder: index
        })
      }
    })
    .filter(Boolean)

  return await Promise.all(promises)
}

export async function addChart(data) {
  const url = `${API_BASE_URL}/echarts/add-chart`
  return await request(url, {
    method: 'POST',
    body: JSON.stringify(data)
  })
}

export async function uploadImg(formData) {
  const token = getToken()

  const url = `${API_BASE_URL}/upload/upload-img`

  const config = {
    method: 'POST',
    headers: {
      ...(token && { Authorization: `Bearer ${token}` })
    },
    body: formData
  }

  const response = await fetch(url, config)

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`)
  }

  const data = await response.json()

  // 检查API返回的code
  if (data.code !== 200) {
    throw new Error(data.msg || '上传失败')
  }

  return data
}

/**
 * 删除图表
 * @param {string|number} id - 图表ID
 * @returns {Promise} 删除结果
 */
export async function deleteChart(id) {
  if (!id) {
    throw new Error('图表ID不能为空')
  }

  const url = `${API_BASE_URL}/echarts/delete-chart/${id}`

  return await request(url, {
    method: 'DELETE'
  })
}

/**
 * 修改密码
 * @param {object} passwordData - 密码数据
 * @param {string} passwordData.oldPassword - 原密码
 * @param {string} passwordData.newPassword - 新密码
 * @returns {Promise} 修改结果
 */
export async function changePassword(passwordData) {
  const { oldPassword, newPassword } = passwordData

  if (!oldPassword || !newPassword) {
    throw new Error('原密码和新密码不能为空')
  }

  const url = `${API_BASE_URL}/auth/change-password`

  return await request(url, {
    method: 'POST',
    body: JSON.stringify({ oldPassword, newPassword })
  })
}

// ============== 管理员功能接口 ==============

/**
 * 获取用户列表（管理员功能）
 * @param {object} params - 查询参数
 * @param {number} params.page - 页码，默认1
 * @param {number} params.limit - 每页数量，默认10
 * @param {string} params.status - 状态筛选，可选值：active, banned
 * @param {string} params.search - 搜索关键词（用户名或邮箱）
 * @returns {Promise} 用户列表数据
 */
export async function getUsersList(params = {}) {
  const { page = 1, limit = 10, status, search } = params

  // 构建查询参数
  const searchParams = new URLSearchParams({
    page: page.toString(),
    limit: limit.toString()
  })

  if (status) {
    searchParams.append('status', status)
  }

  if (search && search.trim()) {
    searchParams.append('search', search.trim())
  }

  const url = `${API_BASE_URL}/auth/admin/users?${searchParams.toString()}`

  return await request(url)
}

/**
 * 更新用户状态（管理员功能）
 * @param {number} userId - 用户ID
 * @param {object} statusData - 状态数据
 * @param {string} statusData.status - 状态：active 或 banned
 * @param {string} statusData.reason - 操作原因（可选）
 * @returns {Promise} 操作结果
 */
export async function updateUserStatus(userId, statusData) {
  const { status, reason } = statusData

  if (!userId) {
    throw new Error('用户ID不能为空')
  }

  if (!status || !['active', 'banned'].includes(status)) {
    throw new Error('状态值无效，只能是 active 或 banned')
  }

  const url = `${API_BASE_URL}/auth/admin/users/${userId}/status`

  return await request(url, {
    method: 'PUT',
    body: JSON.stringify({ status, reason })
  })
}

/**
 * 重置用户密码（管理员功能）
 * @param {number} userId - 用户ID
 * @param {object} resetData - 重置数据
 * @param {string} resetData.newPassword - 新密码
 * @param {boolean} resetData.sendEmail - 是否发送邮件通知，默认false
 * @returns {Promise} 操作结果
 */
export async function adminResetPassword(userId, resetData) {
  const { newPassword, sendEmail = false } = resetData

  if (!userId) {
    throw new Error('用户ID不能为空')
  }

  if (!newPassword) {
    throw new Error('新密码不能为空')
  }

  const url = `${API_BASE_URL}/auth/admin/users/${userId}/reset-password`

  return await request(url, {
    method: 'PUT',
    body: JSON.stringify({ newPassword, sendEmail })
  })
}

/**
 * 删除用户（管理员功能）
 * @param {number} userId - 用户ID
 * @param {object} deleteData - 删除数据
 * @param {boolean} deleteData.confirm - 确认删除，必须为true
 * @returns {Promise} 操作结果
 */
export async function deleteUser(userId, deleteData = {}) {
  const { confirm = false } = deleteData

  if (!userId) {
    throw new Error('用户ID不能为空')
  }

  if (!confirm) {
    throw new Error('删除用户需要确认')
  }

  const url = `${API_BASE_URL}/auth/admin/users/${userId}`

  return await request(url, {
    method: 'DELETE',
    body: JSON.stringify({ confirm })
  })
}

// ============== 咖啡墙支持者管理接口 ==============

/**
 * 获取所有支持者数据
 * @param {object} params - 查询参数
 * @param {number} params.page - 页码，默认1
 * @param {number} params.limit - 每页数量，默认50
 * @param {number} params.typeIndex - 类型索引过滤，可选(0,1,2)
 * @returns {Promise} 支持者列表数据
 */
export async function getSupporters(params = {}) {
  const { page = 1, limit = 50, typeIndex } = params

  // 构建查询参数
  const searchParams = new URLSearchParams({
    page: page.toString(),
    limit: limit.toString()
  })

  if (typeIndex !== undefined) {
    searchParams.append('typeIndex', typeIndex.toString())
  }

  const url = `${API_BASE_URL}/coffee-wall/supporters?${searchParams.toString()}`

  return await request(url)
}

/**
 * 根据ID获取单个支持者
 * @param {string|number} id - 支持者ID
 * @returns {Promise} 支持者详情数据
 */
export async function getSupporterById(id) {
  if (!id) {
    throw new Error('支持者ID不能为空')
  }

  const url = `${API_BASE_URL}/coffee-wall/supporters/${id}`

  return await request(url)
}

/**
 * 添加新的支持者
 * @param {object} supporterData - 支持者数据
 * @param {number} supporterData.count - 支持杯数
 * @param {number} supporterData.typeIndex - 类型索引(0,1,2)
 * @param {boolean} supporterData.hasAvatar - 是否有头像
 * @param {string} supporterData.name - 支持者姓名
 * @param {string} supporterData.avatar - 头像URL，可选
 * @param {string} supporterData.time - 支持时间
 * @param {string} supporterData.message - 支持留言
 * @returns {Promise} 添加结果
 */
export async function addSupporter(supporterData) {
  const { count, typeIndex, hasAvatar, name, avatar, time, message } = supporterData

  if (!count || typeIndex === undefined || !name || !time) {
    throw new Error('支持杯数、类型索引、姓名和时间不能为空')
  }

  if (![0, 1, 2].includes(parseInt(typeIndex))) {
    throw new Error('类型索引必须是 0, 1, 或 2')
  }

  const url = `${API_BASE_URL}/coffee-wall/supporters`

  return await request(url, {
    method: 'POST',
    body: JSON.stringify({ count, typeIndex, hasAvatar, name, avatar, time, message })
  })
}

/**
 * 编辑支持者信息
 * @param {string|number} id - 支持者ID
 * @param {object} supporterData - 支持者数据
 * @param {number} supporterData.count - 支持杯数
 * @param {number} supporterData.typeIndex - 类型索引(0,1,2)
 * @param {boolean} supporterData.hasAvatar - 是否有头像
 * @param {string} supporterData.name - 支持者姓名
 * @param {string} supporterData.avatar - 头像URL，可选
 * @param {string} supporterData.time - 支持时间
 * @param {string} supporterData.message - 支持留言
 * @returns {Promise} 更新结果
 */
export async function updateSupporter(id, supporterData) {
  const { count, typeIndex, hasAvatar, name, avatar, time, message } = supporterData

  if (!id) {
    throw new Error('支持者ID不能为空')
  }

  if (!count || typeIndex === undefined || !name || !time) {
    throw new Error('支持杯数、类型索引、姓名和时间不能为空')
  }

  if (![0, 1, 2].includes(parseInt(typeIndex))) {
    throw new Error('类型索引必须是 0, 1, 或 2')
  }

  const url = `${API_BASE_URL}/coffee-wall/supporters/${id}`

  return await request(url, {
    method: 'PUT',
    body: JSON.stringify({ count, typeIndex, hasAvatar, name, avatar, time, message })
  })
}

/**
 * 删除支持者
 * @param {string|number} id - 支持者ID
 * @returns {Promise} 删除结果
 */
export async function deleteSupporter(id) {
  if (!id) {
    throw new Error('支持者ID不能为空')
  }

  const url = `${API_BASE_URL}/coffee-wall/supporters/${id}`

  return await request(url, {
    method: 'DELETE'
  })
}

// ============== 插画分类管理接口 ==============

/**
 * 获取所有插画分类
 * @param {object} params - 查询参数
 * @param {number} params.page - 页码，默认1
 * @param {number} params.limit - 每页数量，默认10
 * @returns {Promise} 分类列表数据
 */
export async function getIllustrationCategories(params = {}) {
  const { page = 1, limit = 10, search } = params

  // 构建查询参数
  const searchParams = new URLSearchParams({
    page: page.toString(),
    limit: limit.toString()
  })

  // 添加搜索参数
  if (search && search.trim()) {
    searchParams.append('search', search.trim())
  }

  const url = `${API_BASE_URL}/illustrations/categories?${searchParams.toString()}`

  return await request(url)
}

/**
 * 创建插画分类
 * @param {object} categoryData - 分类数据
 * @param {string} categoryData.title - 分类标题
 * @param {string} categoryData.description - 分类描述，可选
 * @returns {Promise} 创建结果
 */
export async function createIllustrationCategory(categoryData) {
  const { title, description } = categoryData

  if (!title) {
    throw new Error('分类标题不能为空')
  }

  const url = `${API_BASE_URL}/illustrations/categories`

  return await request(url, {
    method: 'POST',
    body: JSON.stringify({ title, description })
  })
}

/**
 * 更新插画分类
 * @param {string|number} id - 分类ID
 * @param {object} categoryData - 分类数据
 * @param {string} categoryData.title - 分类标题
 * @param {string} categoryData.description - 分类描述，可选
 * @returns {Promise} 更新结果
 */
export async function updateIllustrationCategory(id, categoryData) {
  const { title, description } = categoryData

  if (!id) {
    throw new Error('分类ID不能为空')
  }

  if (!title) {
    throw new Error('分类标题不能为空')
  }

  const url = `${API_BASE_URL}/illustrations/categories/${id}`

  return await request(url, {
    method: 'PUT',
    body: JSON.stringify({ title, description })
  })
}

/**
 * 删除插画分类
 * @param {string|number} id - 分类ID
 * @returns {Promise} 删除结果
 */
export async function deleteIllustrationCategory(id) {
  if (!id) {
    throw new Error('分类ID不能为空')
  }

  const url = `${API_BASE_URL}/illustrations/categories/${id}`

  return await request(url, {
    method: 'DELETE'
  })
}

// ============== 插画管理接口 ==============

/**
 * 获取分类下的所有插画
 * @param {string|number} categoryId - 分类ID
 * @param {object} params - 查询参数
 * @param {number} params.page - 页码，默认1
 * @param {number} params.limit - 每页数量，默认20
 * @returns {Promise} 插画列表数据
 */
export async function getCategoryIllustrations(categoryId, params = {}) {
  if (!categoryId) {
    throw new Error('分类ID不能为空')
  }

  // 构建查询参数
  const searchParams = new URLSearchParams({})

  const url = `${API_BASE_URL}/illustrations/categories/${categoryId}/illustrations?${searchParams.toString()}`

  return await request(url)
}

/**
 * 上传插画到指定分类
 * @param {string|number} categoryId - 分类ID
 * @param {File} file - SVG文件
 * @returns {Promise} 上传结果
 */
export async function uploadIllustration(categoryId, file) {
  if (!categoryId) {
    throw new Error('分类ID不能为空')
  }

  if (!file) {
    throw new Error('请选择要上传的SVG文件')
  }

  const token = getToken()
  const formData = new FormData()
  formData.append('illustration', file)

  const url = `${API_BASE_URL}/illustrations/categories/${categoryId}/illustrations`

  const config = {
    method: 'POST',
    headers: {
      ...(token && { Authorization: `Bearer ${token}` })
    },
    body: formData
  }

  const response = await fetch(url, config)

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`)
  }

  const data = await response.json()

  // 检查API返回的code
  if (data.code !== 200) {
    throw new Error(data.msg || '上传失败')
  }

  return data
}

/**
 * 删除单个插画
 * @param {string|number} id - 插画ID
 * @returns {Promise} 删除结果
 */
export async function deleteIllustration(id) {
  if (!id) {
    throw new Error('插画ID不能为空')
  }

  const url = `${API_BASE_URL}/illustrations/illustrations/${id}`

  return await request(url, {
    method: 'DELETE'
  })
}

// ============== 字体管理接口 ==============

/**
 * 获取字体列表
 * @param {object} params - 查询参数
 * @param {number} params.page - 页码，默认1
 * @param {number} params.limit - 每页数量，默认20
 * @param {string} params.name - 文件名搜索，可选
 * @returns {Promise} 字体列表数据
 */
export async function getFontsList(params = {}) {
  const { page = 1, limit = 20, name } = params

  // 构建查询参数
  const searchParams = new URLSearchParams({
    page: page.toString(),
    limit: limit.toString()
  })

  if (name && name.trim()) {
    searchParams.append('name', name.trim())
  }

  const url = `${API_BASE_URL}/fonts/list?${searchParams.toString()}`

  return await request(url)
}

/**
 * 上传字体文件
 * @param {File} file - SVG字体文件
 * @returns {Promise} 上传结果
 */
export async function uploadFont(file) {
  if (!file) {
    throw new Error('请选择要上传的字体文件')
  }

  const token = getToken()
  const formData = new FormData()
  formData.append('font', file)

  const url = `${API_BASE_URL}/fonts/upload`

  const config = {
    method: 'POST',
    headers: {
      ...(token && { Authorization: `Bearer ${token}` })
    },
    body: formData
  }

  const response = await fetch(url, config)

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`)
  }

  const data = await response.json()

  // 检查API返回的code
  if (data.code !== 200) {
    throw new Error(data.msg || '上传失败')
  }

  return data
}

/**
 * 删除字体
 * @param {string|number} id - 字体ID
 * @returns {Promise} 删除结果
 */
export async function deleteFont(id) {
  if (!id) {
    throw new Error('字体ID不能为空')
  }

  const url = `${API_BASE_URL}/fonts/${id}`

  return await request(url, {
    method: 'DELETE'
  })
}

// ============== 消息通知接口 ==============

/**
 * 获取未读消息数量
 * @returns {Promise} 未读消息数量
 */
export async function getUnreadNotificationCount() {
  const url = `${API_BASE_URL}/notifications/unread-count`
  return await request(url)
}
